home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 247_02 / number.hpp < prev    next >
Text File  |  1989-04-17  |  6KB  |  155 lines
  1. /*
  2.  *    Experimental MIRACL  C++ Header file
  3.  *
  4.  *    AUTHOR  :    M. Scott
  5.  *
  6.  *    NAME    :    number.hpp
  7.  *             
  8.  *    PURPOSE :    Definition of class GFn  (Arithmetic mod n)
  9.  */
  10.  
  11. overload pow;
  12. overload prime;
  13. overload gcd;
  14.  
  15. #include <string.h>
  16. #include <stdlib.h>
  17. #include <math.h>
  18. #include "miracl.h"
  19.  
  20. extern big w14;                        /* use this to store modulus */
  21.  
  22. void normalise(big b)
  23. { /* normalise a number into range */
  24.     divide(b,w14,w14);
  25.     if (size(b)<0) add(b,w14,b);
  26. }
  27.  
  28. class miracl
  29. { /* dummy class to initialise MIRACL */
  30. public:
  31.     miracl(int nd,small nb=MAXBASE) {mirsys(nd,nb);STROUT=TRUE;POINT=TRUE;}
  32. };
  33.  
  34.  
  35. class GFn 
  36. { 
  37.     big fn;
  38. public:
  39.     GFn()                                               { fn = mirvar(0); } 
  40.     GFn(int i)                                          { fn = mirvar(i); }
  41.     GFn(long lg)                         { fn = mirvar(0); lconv(lg,fn);  }
  42.     GFn(GFn& b)                          { fn = mirvar(0); copy(b.fn,fn); }
  43.     GFn(char* s)     { fn = mirvar(0); strcpy(IBUFF,s); cinnum(fn,stdin); }
  44.  
  45.     GFn& operator=(int i)                    {convert(i,fn); return *this;}
  46.     GFn& operator=(const GFn& b)             {copy(b.fn,fn); return *this;}
  47.     GFn& operator=(char* s){strcpy(IBUFF,s);cinnum(fn,stdin);return *this;}
  48.  
  49.     GFn& operator++()           {incr(fn,1,fn);normalise(fn);return *this;}
  50.     GFn& operator--()           {decr(fn,1,fn);normalise(fn);return *this;}
  51.     GFn& operator+=(int i)      {incr(fn,i,fn);normalise(fn);return *this;}
  52.     GFn& operator+=(const GFn& b)
  53.                               {add(fn,b.fn,fn);normalise(fn);return *this;}
  54.  
  55.     GFn& operator-=(int i)     {decr(fn,i,fn);normalise(fn); return *this;}
  56.     GFn& operator-=(const GFn& b)
  57.                         {subtract(fn,b.fn,fn);normalise(fn); return *this;}
  58.  
  59.     GFn& operator*=(int i)  {premult(fn,i,fn);normalise(fn); return *this;}
  60.     GFn& operator*=(const GFn& b){mad(fn,b.fn,fn,w14,w14,fn);return *this;}
  61.  
  62.     GFn& operator/=(int);       
  63.     GFn& operator/=(const GFn&);
  64.  
  65.     friend GFn operator-(const GFn&);
  66.  
  67.     friend GFn operator+(const GFn&,int);
  68.     friend GFn operator+(int,const GFn&);
  69.     friend GFn operator+(const GFn&, const GFn&);
  70.  
  71.     friend GFn operator-(const GFn&, int);
  72.     friend GFn operator-(int,const GFn&);
  73.     friend GFn operator-(const GFn&, const GFn&);
  74.  
  75.     friend GFn operator*(const GFn&, int);
  76.     friend GFn operator*(int,const GFn&);
  77.     friend GFn operator*(const GFn&, const GFn&);
  78.  
  79.     friend GFn operator/(const GFn&, int);
  80.     friend GFn operator/(int,const GFn&);
  81.     friend GFn operator/(const GFn&, const GFn&);
  82.  
  83.     friend bool operator==(const GFn& b1, const GFn& b2)
  84.              {if (compare(b1.fn,b2.fn)==0) return TRUE; else return FALSE;}
  85.     friend bool operator==(const GFn&,int);
  86.     friend bool operator==(int,const GFn&);
  87.  
  88.     friend bool operator!=(const GFn& b1, const GFn& b2)
  89.              {if (compare(b1.fn,b2.fn)!=0) return TRUE; else return FALSE;}
  90.     friend bool operator!=(const GFn&, int);
  91.     friend bool operator!=(int, const GFn&);
  92.  
  93.     friend bool prime(const GFn& b)                   {return prime(b.fn);}
  94.     friend GFn  gcd(const GFn&,const GFn&);
  95.     friend GFn  pow(const GFn&,int);
  96.     friend GFn  pow(const GFn&,const GFn&);
  97.  
  98.     friend void modulo(const GFn& b)      {copy(b.fn,w14); absol(w14,w14);}
  99.  
  100.     friend istream& operator>>(istream& s, GFn& x)
  101.                            { s >> IBUFF; cinnum(x.fn,stdin) ;   return s; }
  102.     friend ostream& operator<<(ostream& s, GFn& x)
  103.                   { cotnum(x.fn,stdout); if (STROUT) s << OBUFF; return s;}
  104.  
  105.     ~GFn()                                             {free((char *)fn); }
  106. };
  107.  
  108.  
  109. GFn& GFn::operator/=(int k)        {GFn z=k; xgcd(z.fn,w14,z.fn,z.fn,z.fn);
  110.                                   mad(z.fn,fn,fn,w14,w14,fn);return *this;}
  111. GFn& GFn::operator/=(const GFn& b)   {GFn z; xgcd(b.fn,w14,z.fn,z.fn,z.fn);
  112.                                   mad(z.fn,fn,fn,w14,w14,fn);return *this;}
  113.  
  114. GFn operator-(const GFn& b)
  115.             {GFn nb; subtract(w14,b.fn,nb.fn);normalise(nb.fn); return nb;}
  116. GFn operator+(const GFn& b,int i)
  117.             {GFn abi; incr(b.fn, i, abi.fn);normalise(abi.fn); return abi;}
  118. GFn operator+(int i,const GFn& b)
  119.             {GFn aib; incr(b.fn, i, aib.fn);normalise(aib.fn); return aib;}
  120. GFn operator+(const GFn& b1, const GFn& b2)
  121.             {GFn abb;add(b1.fn,b2.fn,abb.fn);normalise(abb.fn);return abb;}
  122.  
  123. GFn operator-(const GFn& b, int i)
  124.             {GFn mbi; decr(b.fn, i, mbi.fn);normalise(mbi.fn); return mbi;}
  125. GFn operator-(int i,const GFn& b)   {GFn mib;decr(b.fn,i,mib.fn);
  126.                        negate(mib.fn,mib.fn);normalise(mib.fn);return mib;}
  127. GFn operator-(const GFn& b1, const GFn& b2)
  128.       {GFn mbb;subtract(b1.fn,b2.fn,mbb.fn);normalise(mbb.fn); return mbb;}
  129.  
  130. GFn operator*(const GFn& b, int i)
  131.          {GFn xbi; premult(b.fn, i, xbi.fn);normalise(xbi.fn); return xbi;}
  132. GFn operator*(int i,const GFn& b)
  133.          {GFn xib; premult(b.fn, i, xib.fn);normalise(xib.fn); return xib;}
  134. GFn operator*(const GFn& b1, const GFn& b2)
  135.              {GFn xbb; mad(b1.fn,b2.fn,xbb.fn,w14,w14,xbb.fn); return xbb;}
  136.  
  137. GFn operator/(const GFn& b, int k)  {GFn z=k;xgcd(z.fn,w14,z.fn,z.fn,z.fn);
  138.                               mad(b.fn,z.fn,z.fn,w14,w14,z.fn);  return z;}
  139. GFn operator/(int k,const GFn& b)    {GFn z; xgcd(b.fn,w14,z.fn,z.fn,z.fn);
  140.                        premult(z.fn,k,z.fn);divide(z.fn,w14,w14);return z;}
  141. GFn operator/(const GFn& b1, const GFn& b2)
  142.                                     {GFn z; xgcd(b2.fn,w14,z.fn,z.fn,z.fn);
  143.                              mad(b1.fn,z.fn,z.fn,w14,w14,z.fn);  return z;}
  144.  
  145. GFn gcd(const GFn& b1,const GFn& b2){GFn z;gcd(b1.fn,b2.fn,z.fn);return z;}
  146. GFn pow(const GFn& b,int n)        {GFn z;power(b.fn,n,w14,z.fn);return z;}
  147. GFn pow(const GFn& b1,const GFn& b2)
  148.                              {GFn z;powmod(b1.fn,b2.fn,w14,z.fn);return z;}
  149.  
  150. bool operator==(const GFn& b, int i)              {GFn z=i; return (b==z);}
  151. bool operator==(int i, const GFn& b)              {GFn z=i; return (z==b);}
  152. bool operator!=(const GFn& b, int i)              {GFn z=i; return (b!=z);}
  153. bool operator!=(int i, const GFn& b)              {GFn z=i; return (z!=b);}
  154.  
  155.